﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <vector>
#include <map>
#include <assert.h>

using namespace std;
//struct Point
//{
//	int _x;
//	int _y;
//};
//class A
//{
//public:
//	//explicit A(int x, int y)  //如果不想让隐式类型转换
//	//	:_x(x)
//	//	,_y(y)
//	//{
//
//	//}
//
//	A(int x, int y)
//		:_x(x)
//		, _y(y)
//	{
//
//	}
//
//	A(int x)
//		:_x(x)
//		, _y()
//	{
//
//	}
//private:
//	int _x;
//	int _y;
//};
//int main()
//{
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int arr[10] = { 0 };
//	Point p = { 1,2 };
//	A a = { 1,2 };
//	//单参数类型隐式转换
//	A aa1 = 1;
//	A aa2 = { 1 };
//
//	//多参数类型隐式转换
//	A aa3 = { 2,2 };
//	const A& aa4 = { 2,2 };
//
//	return 0;
//}


//int main()
//{
//	//可以取消等号
//	int arr[4]{ 1,2,3,4 };
//	int a{ 1 };
//	cout << a << endl;
//	return 0;
//}

//int main()
//{
//	vector<int> v1;
//	vector<int> v2(10,1);
//
//	vector<int> v3 = {1,2,3,4,5};
//	vector<int> v4 = {10,20,30,40,50};
//
//	auto il = { 0,2,6 };
//	initializer_list<int> il2 = { 10,20,30,40 };
//	for(auto e :il2) 
//	{
//		cout << e << endl;
//	}
//	cout << typeid(il).name() << endl;
//	cout << typeid(il2).name() << endl;
//	//std::iterator it = v2.begin();
//	return 0;
//}

////vector<int> v1 = { 1,2,3,4,5,6,7,8,9,10 };
//vector(initializer_list<T> il)
//{
//	reserve(il.size());
//	for (auto& e : il)
//	{
//		push_back(e);
//	}
//}
//int main()
//{
//	pair<string, string> kv1("sort", "排序");
//	pair<string, string> kv2("insert", "插入");
//	map<string, string> dict = { {"sort", "排序"} ,{"insert", "插入"} };
//	for (auto e : dict)
//	{
//		cout << e.first <<" ";
//	}
//	return 0;
//}

//int main()
//{
//	int i = 0;
//	auto& x = i;
//	x++;
//
//	int& j = i;
//	auto y = j;
//	j++;
//	y+=2;
//
//	return 0;
//}


//template<class T1, class T2>
//void F(T1 t1, T2 t2)
//{
//	decltype(t1 * t2) ret;
//	cout << typeid(ret).name() << endl;
//}
//int main()
//{
//	const int x = 1;
//	double y = 2.2;
//	decltype(x * y) ret; // ret的类型是double
//	decltype(&x) p;     //    // p的类型是int*
//	cout << typeid(ret).name() << endl;
//	cout << typeid(p).name() << endl;
//	F(1, 'a');
//	return 0;
//}


#include <list>

//int main()
//{
//	list<int>::iterator it;
//	cout << typeid(it).name() << endl;
//	//不能定义对象
//	//typeid(it1).name() it2;
//	decltype(it) it2;
//	cout << typeid(it2).name() << endl;
//
//	//这个场景Auto更香
//	auto it3 = it;
//
//
//	return 0;
//}

//template<class T>
//class B
//{
//public:
//	T* New(int n)
//	{
//		return new T[n];
//	}
//};
//
//auto func1()
//{
//	list<int> lt;
//	auto ret = lt.begin();
//
//	return ret;
//}
//int main()
//{
//	auto ret3 = func1();
//	B<decltype(ret3)> bb1;
//	cout << typeid(bb1).name() << " ";
//	return 0;
//}


//
//int main()
//{
//	map<string, string> dict = { {"sort","排序"},{"insert","插入"} };
//	for (auto [x, y] : dict)
//	{
//		cout << x << y << " ";
//	}
//	pair<string, string> kv1 = { "sort","排序" };
//	auto [x, y] = kv1;
//	return 0;
//}



//int main()
//{
//	map<string, string> dict = { {"sort","排序"},{"insert","插入"} };
//	for (auto&[x, y] : dict)
//	{
//		cout << x << y << " " << endl;
//		//x += '1';
//		y += '2';
//		cout << x << y << " " << endl;
//
//	}
//	return 0;
//}
#include<array>


//int main()
//{
//	array<int, 10> a1;
//	vector<int> a2(10, 0);
//	for (auto e : a1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	for (auto e : a2)
//	{
//		cout << e << " ";
//	}
//
//	return 0;
//}




//左值引用和右值引用
//传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们
//之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。
//什么是左值？什么是左值引用？
//左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋
//值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左
//值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

//int main()
//{
//	//能否取地址
//	int a = 10; //左值
//	int b = a;  //左值
//	const int c = 10;
//	cout << &a << endl;
//	cout << &b << endl;
//	cout << &c << endl;
//
//	int* p = &a;
//	cout << &(*p) << endl;
//
//	return 0;
//}
#include <string>
//int main()
//{
//	10;
//	string("11111");
//	cout << &to_string(123);
//	x + y;
//	函数();
//
//	return 0;
//}



//int main()
//{
//	double x = 1.1, y = 2.2;
//	// 以下几个都是常见的右值
//	10;
//	x + y;
//	fmin(x, y);
//	// 以下几个都是对右值的右值引用
//	int&& rr1 = 10;
//	double&& rr2 = x + y;
//	double&& rr3 = fmin(x, y);
//	// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
//	10 = 1;
//	x + y = 1;
//	fmin(x, y) = 1;
//	return 0;
//}


////右值引用
//int main()
//{
//	int x = 1;
//	int y = 2;
//	int&& ref = (x + y);
//	string&& ref2 = string("1111111");
//	string&& ref3 = to_string(123);
//	int&& ref4 = 10;
//	return 0;
//}

//int main()
//{
//	// 左值引用能否给右值引用取别名  --- 不可以 但是const左值引用可以
//	const string& ref1 = string("1111");
//	const int& ref2 = 10;
//
//	//右值引用能否给左值取别名   ----不可以但是move以后就可以啦
//	string s1("1111");
//	string&& rref5 = move(s1);
//
//	return 0;
//}


//void func(const string& s);
//string &func1();
//// 左值引用返回值的问题没有彻底解决
//int main()
//{
//
//	return 0;
//}


//杨辉三角
//vector<vector<int>> vv;
//class solution
//{
//public:
//	void generate(int numRows, vector<vector<int>>& vv)
//	{
//		vv.reserve(numRows);
//		for (size_t i = 0; i < length; i++)
//		{
//
//		}
//	}
//};
#include <string>

//int main()
//{
//	std::string&& s1 = std::string("11111111");
//	// s1 是左值 （右值引用本身是左值）
//	cout << &s1 << " ";
//	return 0;
//}


//int main()
//{
//	string s3("22222222");
//	string& s4 = s3;
//	cout << &s4 << endl;
//
//
//	return 0;
//}



//int main()
//{
//	list<string> lt;
//	string s1("“1111111");
//	lt.push_back(s1);  //构造 + 拷贝构造
//	for (auto& e : lt)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//	lt.push_back(string("222222")); //构造 + 拷移动构造
//	for (auto& e : lt)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	 
//	lt.push_back("1111");	// 构造 + 移动构造
//	for (auto& e : lt)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//	list<int> lt1;
//	int x = 20;
//	lt1.push_back(x);
//
//	lt1.push_back(20);  //没有区别
//
//
//	return 0;
//}
//void Fun(int& x) { cout << "左值引用" << endl; }
//void Fun(const int& x) { cout << "const 左值引用" << endl; }
//void Fun(int&& x) { cout << "右值引用" << endl; }
//void Fun(const int&& x) { cout << "const 右值引用" << endl; }
//
//template<typename T>
//void PerfectForward(T&& t)
//{
//	Fun(forward<T>(t));
//}
//void PerfectForward(int& t)
//{
//	Fun(t);
//}
//void PerfectForward(int&& t)
//{
//	Fun(move(t));
//}
//void PerfectForward(const int& t)
//{
//	Fun(t);
//}
//void PerfectForward(const int&& t)
//{
//	Fun(move(t));
//}
//
//int main()
//{
//	PerfectForward(10);  //右值
//
//	int a;
//	PerfectForward(a);  //左值
//	PerfectForward(move(a));  //右值
//
//	const int b = 8;
//	PerfectForward(b);//左值
//	PerfectForward(move(b));//右值
//
//	return 0;
//}
#include <algorithm>
//struct Goods
//{
//	string _name;
//	double _price;
//	int _evaluate;
//
//	Goods(const char* str, double price, int evaluate)
//		:_name(str)
//		, _price(price)
//		, _evaluate(evaluate)
//	{}
//};
//
//struct ComparePriceLess
//{
//	bool operator()(const Goods& gl, const Goods& gr)
//	{
//		return gl._price < gl._price;
//	}
//};
//
//struct ComparePriceGreater
//{
//	bool operator()(const Goods& gl, const Goods& gr)
//	{
//		return gl._price > gl._price;
//	}
//};
//int main()
//{
//	vector<Goods> v = { {"苹果",2.1,5},{"香蕉",3.1,4}, {"菠萝",4.1,6} };
//	sort(v.begin(), v.end(), ComparePriceGreater()); //仿函数
//
//	sort(v.begin(), v.end(), ComparePriceLess());
//
//
//	return 0;
//}

///lambda
//int main()
//{
//	auto add1 = [](int a, int b)->int {return a + b; };
//	cout << add1(1, 2) << endl;
//	auto add2 = [](int a, int b, int c) {return a + b + c; };
//	cout << add2(1, 2, 3) << endl;
//	return 0;
//}




//struct Goods
//{
//	string _name;
//	double _price;
//	int _evaluate;
//
//	Goods(const char* str, double price, int evaluate)
//		:_name(str)
//		, _price(price)
//		, _evaluate(evaluate)
//	{}
//};
//int main()
//{
//	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
//		   3 }, { "菠萝", 1.5, 4 } };
//	auto priceLess = [](const Goods& g1, const Goods& g2) {return g1._price < g1._price;  };
//	auto priceGreater = [](const Goods& g1, const Goods& g2) {return g1._price > g1._price;  };
//	auto evaluateLess = [](const Goods& g1, const Goods& g2) {return g1._evaluate < g1._evaluate;  };
//	auto evaluateGreater = [](const Goods& g1, const Goods& g2) {return g1._evaluate > g1._evaluate;  };
//	sort(v.begin(), v.end(), priceLess);
//	sort(v.begin(), v.end(), priceGreater);
//	sort(v.begin(), v.end(), evaluateLess);
//	sort(v.begin(), v.end(), evaluateGreater);
//	return 0;
//}
//int main()
//{
//	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
//   3 }, { "菠萝", 1.5, 4 } };
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._price < g2._price; });
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._price > g2._price; });
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._evaluate < g2._evaluate; });
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._evaluate > g2._evaluate; });
//}


//int main()
//{
//	auto a = 1, b = 2;
//	auto swap1 = [](int& x, int& y)
//		{
//			int temp = x;
//			x = y;
//			y = temp;
//		};
//	swap1(a, b);
//	return 0;
//}

//int main()
//{
//	auto a = 1, b = 2;
//	auto swap1 = [](int& x, int& y)
//		{
//			int temp = x;
//			x = y;
//			y = temp;
//		};
//	swap1(a, b);
//	//捕捉列表 给lambda
//	auto swap2 = [a,b]() mutable   //mutable可以修改捕捉对象
//		{
//			int temp = a;
//			a = b;
//			b = temp;
//		};
//
//	swap2();
//
//	auto swap3 = [&a, &b]()
//		{
//			int temp = a;
//			a = b;
//			b = temp;
//		};
//	swap3();
//
//	return 0;
//}
//

//
//int main()
//{
//	int a = 1, b = 2, c = 3,d = 4, e = 5;
//	auto func = [=]()
//		{
//			return a + b + c + d + e;
//		};
//	cout << func() << endl;
//
//	auto func1 = [&a, b, c, &d, e]
//		{
//			;
//		};
//
//	return 0;
//}
//
//
//
//


//class HeapOnly
//{
//public:
//	static HeapOnly* CreatObj()
//	{
//		return new HeapOnly;
//	}
//
//	HeapOnly(const HeapOnly&) = delete;
//private:
//	//HeapOnly(const HeapOnly&); c++98
//
//
//	HeapOnly()
//	{
//
//	}
//};
//int main()
//{
//	HeapOnly* p2 = HeapOnly::CreatObj();
//
//	//不能拷贝才能禁止
//	HeapOnly obj(*p2);
//	return 0;
//}

//template<class ...Args>
//void ShowList(Args... args)
//{
//	cout << sizeof...(args) << endl;
//	for (size_t i = 0; i < sizeof...(args); i++) ///不可以
//	{
//		cout << args[i] << endl;
//	}
//}
//
//int main()
//{
//	ShowList(1);
//	ShowList(1,'a');
//	ShowList(1,'a',4);
//	return 0;
//}

//void _CPP_Print()
//{
//	cout << endl;
//}
//template<class T ,class ...Args>
//void _CPP_Print(const T&val ,Args... args)
//{
//	cout << val << endl; 
//	_CPP_Print(args...);
//
//}
//template<class ...Args>
//void Cpp_Printf(Args... args)
//{
//	_CPP_Print(args...);
//}
//int main()
//{
//	Cpp_Printf(1);
//	Cpp_Printf(1, 'a');
//	Cpp_Printf(1, 'a', 4);
//	return 0;
//}


//int main()
//{
//	auto add1 = [](int a, int b)
//		{
//			return a + b;
//		};
//
//	add1(1, 2);
//
//	int a = 1, b = 2;
//	auto swap = [&]()
//		{
//			int temp = a;
//			a = b;
//			b = temp;
//		};
//	return 0;
//}



namespace bit
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			cout << "string(char* str) -- 构造" << endl;

			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// s1.swap(s2)
		void swap(string& ss)
		{
			::swap(_str, ss._str);
			::swap(_size, ss._size);
			::swap(_capacity, ss._capacity);
		}

		// 拷贝构造
		// 左值
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}

		// 移动构造  -- 移动将亡值对象的资源
		// 右值(将亡值)
		string(string&& s)
			:_str(nullptr)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			swap(s);
		}

		// 赋值重载
		// s3 = 左值
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			char* tmp = new char[s._capacity + 1];
			strcpy(tmp, s._str);

			delete[] _str;
			_str = tmp;
			_size = s._size;
			_capacity = s._capacity;

			return *this;
		}

		// s3 = 将亡值
		string& operator=(string&& s)
		{
			cout << "string(string&& s) -- 移动赋值" << endl;
			swap(s);

			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;

				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};

	bit::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}

		bit::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;

			str += ('0' + x);
		}

		if (flag == false)
		{
			str += '-';
		}

		std::reverse(str.begin(), str.end());

		// return move(str);
		return str;
	}
}

//int main()
//{
//	list<pair<bit::string,int>> lt;
//
//	pair<bit::string, int> kv("xxxxx", 1);
//	lt.push_back(kv);
//	lt.push_back(move(kv));
//
//	cout << endl;
//
//	//pair<bit::string, int> kv2("xxxxx", 1);
//	//lt.emplace_back(kv2);
//	//lt.emplace_back(move(kv2));
//		
//	lt.emplace_back("xxxxx", 1);
//
//	return 0;
//}
//#include <functional>
//
//int f(int a, int b)
//{
//	return a + b;
//}
//
//struct Functor
//{
//public:
//	int operator() (int a, int b)
//	{
//		return a + b;
//	}
//};
//
//int main()
//{
//	function<int(int, int)> fc1;
//
//	function<int(int, int)> fc2 = f;
//	function<int(int, int)> fc3 = Functor();
//	function<int(int, int)> fc4 = [](int x, int y) {return x + y; };
//
//	//cout << fc1(1, 2) << endl;
//	cout << fc2.operator()(1, 2) << endl;
//
//	cout << fc3(1, 2) << endl;
//	cout << fc4(1, 2) << endl;
//	return 0;
//}
// 
// 
// 
#include <stack>
//class Solution
//{
//public:
//	int evalRPN(vector<string>& tokens)
//	{
//		stack<int> st;
//		map<string, is_function<int(int, int)>> opFunction =
//		{
//			{"+",[](int x,int y) {return x + y; }},
//			{"-",[](int x,int y) {return x - y; }},
//			{"*",[](int x,int y) {return x * y; }},
//			{"/",[](int x,int y) {return x / y; }},
//		};
//		for (auto& std : tokens)
//		{
//			if (opFunction.count(str))
//			{
//				int right = st.top();
//				st.pop();
//				int left = st.top();
//				st.pop();
//
//				st.push(opFunction[str](left, right));
//			}
//			else
//			{
//				st.push(stoi(str));
//			}
//		}
//	}
//	return st.top();
//
//};


//class Solution {
//public:
//	int evalRPN(vector<string>& tokens) {
//		stack<int> st;
//		map<string, function<int(int, int)>> opFuncMap =
//		{
//			{"+",[](int i,int j) {return i + j; }},
//			{"-",[](int i,int j) {return i - j; }},
//			{"*",[](int i,int j) {return i * j; }},
//			{"/",[](int i,int j) {return i / j; }},
//		};
//
//		for (auto& str : tokens)
//		{
//			if (opFuncMap.count(str))
//			{
//				int right = st.top();
//				st.pop();
//				int left = st.top();
//				st.pop();
//
//				st.push(opFuncMap[str](left, right));
//			}
//			else
//			{
//				st.push(stoi(str));
//			}
//		}
//		return st.top();
//	}
//};

#include<functional>


//class Plus
//{
//public:
//	static int plusi(int a, int b)
//	{
//		return a + b;
//	}
//
//	double plusd(double a, double b)
//	{
//		return a + b;
//	}
//};
//
//int main()
//{
//	function<int(int, int)> fc1 = Plus::plusi;  //因为是静态的static
//	cout << fc1(1, 2) << endl;
//
//	function<double(Plus*,double, double)> fc2 = &Plus::plusd;  //因为前面有个this指针
//	Plus plus;
//	cout << fc2(&plus, 1.1, 2.2) << endl;
//
//	function<double(Plus, double, double)> fc3 = &Plus::plusd;
//	cout << fc3(Plus(), 1.1, 2.2) << endl;   //推荐
//
//	return 0;
//}


//std::function在头文件<functional>
//// 类模板原型如下
//template <class T> function;     // undefined
//template <class Ret, class... Args>
//class function<Ret(Args...)>;
//模板参数说明：
//Ret : 被调用函数的返回类型
//Args…：被调用函数的形参

// 使用方法如下：
#include <functional>
int f(int a, int b)
{
	return a + b;
}
struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};
class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}
};
//int main()
//{
//	// 函数名(函数指针)
//	std::function<int(int, int)> func1 = f;
//	cout << func1(1, 2) << endl;
//	// 函数对象
//	std::function<int(int, int)> func2 = Functor();
//	cout << func2(1, 2) << endl;
//	// lamber表达式
//	std::function<int(int, int)> func3 = [](const int a, const int b)
//		{return a + b; };
//	cout << func3(1, 2) << endl;
//
//	// 类的成员函数
//	std::function<int(int, int)> func4 = &Plus::plusi;
//	cout << func4(1, 2) << endl;
//	std::function<double(Plus, double, double)> func5 = &Plus::plusd;
//	cout << func5(Plus(), 1.1, 2.2) << endl;
//	return 0;
//}
//

//int Plus(int a, int b)
//{
//	return a + b;
//}
//class Sub
//{
//public:
//	int sub(int a, int b)
//	{
//		return a - b;
//	}
//};
//
//int subPlus(int a,int b)
//{
//	return a + b;
//}
//
//int main()
//{
//	auto f1 = subPlus;
//	cout << f1(10, 5) << endl;   //5
//	
//	//调整顺序
//	auto f2 = bind(subPlus(), placeholders::_2, placeholders::_1);
//	cout << f2(10, 5) << endl;   //-5
//
//	//调整 参数个数
//	auto f4 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
//	cout << f4(10, 5);
//
//	auto f4 = bind(&Sub::sub, &sub, placeholders::_1, placeholders::_2);
//	cout << f4(10, 5);
//
//	return 0;
//}


void fx(const string& name, int x, int y)
{
	cout << name << "->[" << "血量:" << x << ",蓝:" << y << ']' << endl;
}

template<class T>
void fy(int n)
{
	T* p = new T[n];
}
int main()
{
	auto f1 = bind(fx,"王昭君", placeholders::_1, placeholders::_2);
	f1(80, 20);
	f1(90, 30);
	f1(100, 40);
	f1(100, 50);
	f1(90, 30);

	auto f2 = bind(fx, "亚索", placeholders::_1, placeholders::_2);
	f2(100, 0);
	f2(90, 0);
	f2(80, 0);
	f2(70, 0);
	f2(60, 0);
	f2(50, 0);
	f2(0, 0);

	auto f3 = bind(fx, "武则天", 100, placeholders::_1);  //外挂 血条绑死
	f3(100, 0);
	f3(90, 0);
	f3(80, 0);
	f3(70, 0);
	f3(60, 0);
	f3(50, 0);
	f3(0, 0);

	auto f4 = bind(fx, "张艳丽", 100, 100);
	f4();
	f4();
	f4();
	f4();
	f4();
	f4();
	f4();

	function<void(string, int)> f5 = bind(fx, placeholders::_1, 80, placeholders::_2);
	f5("武则天", 50);
	f5("韩信", 50);
	f5("刘邦", 50);


	return 0;
}

// 
//namespace bit
//{
//	class string
//	{
//	public:
//		typedef char* iterator;
//		typedef const char* const_iterator;
//
//		const_iterator begin() const
//		{
//			return _str;
//		}
//
//		const_iterator end() const
//		{
//			return _str + _size;
//		}
//
//		iterator begin()
//		{
//			return _str;
//		}
//
//		iterator end()
//		{
//			return _str + _size;
//		}
//
//		/*	string()
//				:_str(new char[1])
//				,_size(0)
//				,_capacity(0)
//			{
//				_str[0] = '\0';
//			}
//
//			string(const char* str)
//				:_size(strlen(str))
//				,_str(new char[strlen(str)+1])
//				,_capacity(strlen(str))
//			{
//				strcpy(_str, str);
//			}*/
//
//		const char* c_str() const
//		{
//			return _str;
//		}
//
//		//string(const char* str = "\0")
//		string(const char* str = "")
//			:_size(strlen(str))
//		{
//			_capacity = _size;
//			_str = new char[_capacity + 1];
//			strcpy(_str, str);
//		}
//
//		// s2(s1)
//		/*string(const string& s)
//		{
//			_str = new char[s._capacity + 1];
//			strcpy(_str, s._str);
//			_size = s._size;
//			_capacity = s._capacity;
//		}*/
//
//		// s2(s1)
//		string(const string& s)
//		{
//			string tmp(s._str);
//			swap(tmp);
//		}
//
//		string& operator=(string tmp)
//		{
//			// 现代写法
//			swap(tmp);
//
//			return *this;
//		}
//
//		// s1 = s3;
//		/*string& operator=(const string& s)
//		{
//			char* tmp = new char[s._capacity + 1];
//			strcpy(tmp, s._str);
//
//			delete[] _str;
//			_str = tmp;
//			_size = s._size;
//			_capacity = s._capacity;
//
//			return *this;
//		}*/
//
//		~string()
//		{
//			delete[] _str;
//			_str = nullptr;
//			_size = _capacity = 0;
//		}
//
//		// 遍历
//		size_t size() const
//		{
//			return _size;
//		}
//
//		size_t capacity() const
//		{
//			return _capacity;
//		}
//
//		char& operator[](size_t pos)
//		{
//			assert(pos < _size);
//
//			return _str[pos];
//		}
//
//		const char& operator[](size_t pos) const
//		{
//			assert(pos < _size);
//
//			return _str[pos];
//		}
//
//		void resize(size_t n, char ch = '\0')
//		{
//			if (n <= _size)
//			{
//				_str[n] = '\0';
//				_size = n;
//			}
//			else
//			{
//				reserve(n);
//				for (size_t i = _size; i < n; i++)
//				{
//					_str[i] = ch;
//				}
//				_str[n] = '\0';
//				_size = n;
//			}
//		}
//
//		void reserve(size_t n)
//		{
//			if (n > _capacity)
//			{
//				char* tmp = new char[n + 1];
//				strcpy(tmp, _str);
//				delete[] _str;
//				_str = tmp;
//
//				_capacity = n;
//			}
//		}
//
//		void push_back(char ch)
//		{
//			// 扩容2倍
//			/*if (_size == _capacity)
//			{
//				reserve(_capacity == 0 ? 4 : 2 * _capacity);
//			}
//
//			_str[_size] = ch;
//			++_size;
//			_str[_size] = '\0';*/
//			insert(_size, ch);
//		}
//
//		void append(const char* str)
//		{
//			// 扩容
//			/*size_t len = strlen(str);
//			if (_size + len > _capacity)
//			{
//				reserve(_size + len);
//			}
//
//			strcpy(_str + _size, str);
//			_size += len;*/
//			insert(_size, str);
//		}
//
//		string& operator+=(char ch)
//		{
//			push_back(ch);
//			return *this;
//		}
//
//		string& operator+=(const char* str)
//		{
//			append(str);
//			return *this;
//		}
//
//		void insert(size_t pos, char ch)
//		{
//			assert(pos <= _size);
//
//			// 扩容2倍
//			if (_size == _capacity)
//			{
//				reserve(_capacity == 0 ? 4 : 2 * _capacity);
//			}
//
//			/*int end = _size;
//			while (end >= (int)pos)
//			{
//				_str[end + 1] = _str[end];
//				--end;
//			}*/
//
//			size_t end = _size + 1;
//			while (end > pos)
//			{
//				_str[end] = _str[end - 1];
//				--end;
//			}
//
//			_str[pos] = ch;
//			++_size;
//		}
//
//		void insert(size_t pos, const char* str)
//		{
//			assert(pos <= _size);
//			size_t len = strlen(str);
//			if (_size + len > _capacity)
//			{
//				// 扩容
//				reserve(_size + len);
//			}
//
//			size_t end = _size + len;
//			while (end > pos + len - 1)
//			{
//				_str[end] = _str[end - len];
//				end--;
//			}
//
//			strncpy(_str + pos, str, len);
//			_size += len;
//		}
//
//		void erase(size_t pos, size_t len = npos)
//		{
//			assert(pos < _size);
//
//			if (len == npos || len >= _size - pos)
//			{
//				_str[pos] = '\0';
//				_size = pos;
//			}
//			else
//			{
//				strcpy(_str + pos, _str + pos + len);
//				_size -= len;
//			}
//		}
//
//		void swap(string& s)
//		{
//			std::swap(_str, s._str);
//			std::swap(_size, s._size);
//			std::swap(_capacity, s._capacity);
//		}
//
//		size_t find(char ch, size_t pos = 0) const
//		{
//			assert(pos < _size);
//
//			for (size_t i = pos; i < _size; i++)
//			{
//				if (_str[i] == ch)
//					return i;
//			}
//
//			return npos;
//		}
//
//		// 20:15继续
//		size_t find(const char* sub, size_t pos = 0) const
//		{
//			assert(pos < _size);
//
//			const char* p = strstr(_str + pos, sub);
//			if (p)
//			{
//				return p - _str;
//			}
//			else
//			{
//				return npos;
//			}
//		}
//
//		string substr(size_t pos = 0, size_t len = npos)
//		{
//			string sub;
//			//if (len == npos || len >= _size-pos)
//			if (len >= _size - pos)
//			{
//				for (size_t i = pos; i < _size; i++)
//				{
//					sub += _str[i];
//				}
//			}
//			else
//			{
//				for (size_t i = pos; i < pos + len; i++)
//				{
//					sub += _str[i];
//				}
//			}
//
//			return sub;
//		}
//
//		void clear()
//		{
//			_size = 0;
//			_str[_size] = '\0';
//		}
//	private:
//		char* _str = nullptr;
//		size_t _size = 0;
//		size_t _capacity = 0;
//
//	public:
//		static const int npos;
//	};
//
//	const int string::npos = -1;
//
//	void swap(string& x, string& y)
//	{
//		x.swap(y);
//	}
//
//	bool operator==(const string& s1, const string& s2)
//	{
//		int ret = strcmp(s1.c_str(), s2.c_str());
//		return ret == 0;
//	}
//
//	bool operator<(const string& s1, const string& s2)
//	{
//		int ret = strcmp(s1.c_str(), s2.c_str());
//		return ret < 0;
//	}
//
//	bool operator<=(const string& s1, const string& s2)
//	{
//		return s1 < s2 || s1 == s2;
//	}
//
//	bool operator>(const string& s1, const string& s2)
//	{
//		return !(s1 <= s2);
//	}
//
//	bool operator>=(const string& s1, const string& s2)
//	{
//		return !(s1 < s2);
//	}
//
//	bool operator!=(const string& s1, const string& s2)
//	{
//		return !(s1 == s2);
//	}
//
//	ostream& operator<<(ostream& out, const string& s)
//	{
//		for (auto ch : s)
//		{
//			out << ch;
//		}
//
//		return out;
//	}
//
//	// 21:15
//	istream& operator>>(istream& in, string& s)
//	{
//		s.clear();
//
//		char ch;
//		//in >> ch;
//		ch = in.get();
//		char buff[128];
//		size_t i = 0;
//		while (ch != ' ' && ch != '\n')
//		{
//			buff[i++] = ch;
//			// [0,126]
//			if (i == 127)
//			{
//				buff[127] = '\0';
//				s += buff;
//				i = 0;
//			}
//
//			ch = in.get();
//		}
//
//		if (i > 0)
//		{
//			buff[i] = '\0';
//			s += buff;
//		}
//
//		return in;
//	}
//}
//
//	//istream& operator>>(istream& in, string& s)
//	//{
//	//	s.clear();
//	//	char ch;
//	//	//in >> ch;
//	//	ch = in.get();
//	//	s.reserve(128);
//	//	while (ch != '\n' && ch != ' ')
//	//	{
//	//		s += ch;
//	//		ch = in.get();
//	//	}
//
//	//	return in;
//	//}
//
//	istream& getline(istream& in, string& s)
//	{
//		s.clear();
//
//		char ch;
//		//in >> ch;
//		ch = in.get();
//		char buff[128];
//		size_t i = 0;
//		while (ch != '\n')
//		{
//			buff[i++] = ch;
//			// [0,126]
//			if (i == 127)
//			{
//				buff[127] = '\0';
//				s += buff;
//				i = 0;
//			}
//
//			ch = in.get();
//		}
//
//		if (i > 0)
//		{
//			buff[i] = '\0';
//			s += buff;
//		}
//
//		return in;
//	}
//
//
//template<class T>
//struct ListNode
//{
//	ListNode* _next = nullptr;
//	ListNode* _prev = nullptr;
//	T _data;
//};
//template<class T>
//class List
//{
//	typedef ListNode<T> Node;
//public:
//	List()
//	{
//		_head = new Node;
//		_head->_next = _head;
//		_head->_prev = _head;
//	}
//	void PushBack(T&& x)
//	{
//		//Insert(_head, x);
//		Insert(_head, std::forward<T>(x));
//	}
//	void PushFront(T&& x)
//	{
//		//Insert(_head->_next, x);
//		Insert(_head->_next, std::forward<T>(x));
//	}
//	void Insert(Node* pos, T&& x)
//	{
//		Node* prev = pos->_prev;
//		Node* newnode = new Node;
//		newnode->_data = std::forward<T>(x); // 关键位置
//		// prev newnode pos
//		prev->_next = newnode;
//		newnode->_prev = prev;
//		newnode->_next = pos;
//		pos->_prev = newnode;
//	}
//	void Insert(Node* pos, const T& x)
//	{
//		Node* prev = pos->_prev;
//		Node* newnode = new Node;
//		newnode->_data = x; // 关键位置
//		// prev newnode pos
//		prev->_next = newnode;
//		newnode->_prev = prev;
//		newnode->_next = pos;
//		pos->_prev = newnode;
//	}
//private:
//	Node* _head;
//};
//int main()
//{
//	List<bit::string> lt;
//	lt.PushBack("1111");
//	lt.PushFront("2222");
//	return 0;
//}

